The modern communications era has brought about a tremendous expansion of wireline and wireless networks. Computer networks, television networks, and telephony networks are experiencing an unprecedented technological expansion, fueled by consumer demand. Wireless and mobile networking technologies have addressed related consumer demands, while providing more flexibility and immediacy of information transfer.
Current and future networking technologies continue to facilitate ease of information transfer and convenience to users. One area in which there is a demand to increase ease of information transfer and convenience to users relates to sharing of resources between different processes (e.g., an instance of a computer program). These processes may be interconnected with each other and may be executed on a single electronic device or may be executed on multiple electronic devices. One example of a benefit of sharing resources between processes is that such sharing permits simultaneous execution of one or more instructions from different processes which fosters efficient use of resources in electronic devices. Another example of a benefit of sharing resources between interconnected processes is that it allows different processes to share the same set of instructions in memory in order to conserve storage space in electronic devices.
Existing solutions relating to the sharing of resources between processes typically consist of providing file descriptors to processes. In this regard, the file descriptors may serve as keys for accessing resources to be shared such as a file, directory, memory, etc. via an interprocess communication. However, existing solutions relating to the sharing of resources between processes suffer from a drawback of being very inflexible. For example, a UNIX domain socket may be used to send data between one or more processes and these processes can send file descriptors to each other, for sharing resources, across a UNIX domain socket connection using sendmsg( ) and recvmsg( ) system calls with Software Configuration Management (SCM) rights. However, existing solutions such as the UNIX domain socket using the sendmsg( ) and recvmsg( ) functions with SCM rights do not typically provide any mechanism to terminate the usage of a resource after the interprocess communication has ended. Also, there is no suitable mechanism to limit the passing of a resource from one process to another process once the resource is shared. As such, there is currently no suitable mechanism for limiting how long these resources can be shared between processes. In other words, when access to these resources is granted, the access is typically granted indefinitely and there is no suitable mechanism to remove the access rights to a shared resource once they are granted to a process and this is typically the case even when a connection between the processes is removed.
Another drawback of using the existing solutions to granting access for shared resources is that these solutions are tightly coupled or tied to a specific protocol and application programming interface (API) such as the UNIX domain socket using the sendmsg( ) and recvmsg( ) function calls with the SCM rights. Usage of this specific protocol and API forces all communication with respect to the interconnected processes to be rewritten to conform to this specific protocol and API, which is oftentimes not desirable and may result in an inefficient use of resources. In this regard, the existing solutions may force an application to use a specific API (e.g., UNIX domain socket) for accessing a shared resource instead of the API that the application or process would normally use for such a resource. For instance, the UNIX API may for example use a special “dup( )” function call to access a shared resource whereas a normal API may use a normal open( ) function to access a resource. When using the UNIX API, the normal open( ) function may need to be rewritten or changed to another function corresponding to the UNIX API such as for example the special “dup( )” function call. Most importantly, since traditional UNIX systems are multiuser devices the usage of access control mechanisms are typically limited to protect processes and resources of different users from each other. In contrast, any mobile device is typically a single user device e.g., a personal device, thus traditional access control mechanisms used in UNIX systems are typically not applicable. Therefore, a new access control mechanism to protect processes and their resources from each other is needed. The importance of this change has increased because of the wide adoption of UNIX standards (e.g. Portable Operating System Interface for Unix (POSIX)) and UNIX based operating systems in mobile devices (e.g. Linux Operating System (OS) and Berkeley Software Distribution (BSD) OS variants).
Accordingly, it may be desirable to provide a different mechanism by which to share resources via an interprocess communication to allow sharing of resources between interconnected processes in a secure and flexible manner.